package com.hmkj.core.api.ufx.mc;

import com.hmkj.boot.utils.SpringContextUtils;
import com.hmkj.core.api.ufx.model.res.DealPush;
import com.hmkj.core.api.ufx.model.res.EntrustPush;
import com.hmkj.core.constant.CacheID;
import com.hmkj.core.constant.ConfigNID;
import com.hmkj.core.model.quote.DealData;
import com.hmkj.core.model.quote.KData;
import com.hmkj.core.model.quote.RealTimeData;
import com.hmkj.core.model.quote.SimpleRealData;
import com.hmkj.core.service.cache.RedisService;
import com.hundsun.mcapi.interfaces.ISubCallback;
import com.hundsun.mcapi.subscribe.MCSubscribeParameter;
import com.hundsun.t2sdk.interfaces.share.dataset.IDataset;
import com.hundsun.t2sdk.interfaces.share.event.IEvent;
import com.xiaoleilu.hutool.util.StrUtil;
import com.xiaoleilu.hutool.util.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;

import java.text.SimpleDateFormat;
import java.util.*;

@Slf4j
public class MCCallback implements ISubCallback {

    private static RedisService redisService = SpringContextUtils.getBean(RedisService.class);

    // 系统标识
//    private static String prefix = redisService.get(ConfigNID.SYS_FLAG) + "_";

    public static final SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    @Override
    public void OnReceived(String paramString, IEvent paramIEvent) {
//        try {
//            StringBuilder sb = new StringBuilder();
//            //获取结果集
//            IDataset ds = paramIEvent.getEventDatas().getDataset(0);
//            int columnCount = ds.getColumnCount();
//            //打印结果集标注
//            for (int j = 1; j <= columnCount; j++) {
//                sb.append(ds.getColumnName(j));
//                sb.append("|");
//            }
//            //遍历单个结果集记录，遍历前首先将指针置到开始
//            ds.beforeFirst();
//            while (ds.hasNext()) {
//                sb.append("\n");
//                ds.next();
//                //打印结果集数据
//                for (int j = 1; j <= columnCount; j++) {
//                    sb.append(ds.getString(j)).append("|");
//                }
//            }
//
//
//            if ("ovfutu.trade_push".equals(paramString) || "futu.trade_push".equals(paramString)) {
//                // 整理推送数据
//                Map<String, String> datas = analysisData(sb);
//                // 交易主推
//                switch (datas.get("msg_type")) {
//                    case "1001":
//                        // 期货委托回报，推送委托回报队列处理
//                        if (StrUtil.isNotBlank(datas.get("entrust_reference")) && datas.get("entrust_reference").startsWith(prefix)) {
//                            log.info("委托推送数据：\n{}", sb.toString());
//                            datas.put("entrust_reference", datas.get("entrust_reference").replace(prefix, ""));
//                            redisService.push(CacheID.QUEUE_ENTRUST_PUSH, EntrustPush.buildData(datas, paramString));
//                        } else {
//                            log.error("其他平台委托推送数据，舍弃处理：{}", datas.get("entrust_reference") + "_" + datas.get("futu_entrust_no"));
//                        }
//                        break;
//                    case "1002":
//                        // 期货成交回报，推送成交回报队列处理
//                        if (StrUtil.isNotBlank(datas.get("entrust_reference")) && datas.get("entrust_reference").startsWith(prefix)) {
//                            log.info("成交推送数据：\n{}", sb.toString());
//                            datas.put("entrust_reference", datas.get("entrust_reference").replace(prefix, ""));
//                            redisService.push(CacheID.QUEUE_DEAL_PUSH, DealPush.buildData(datas, paramString));
//                        } else {
//                            log.error("其他平台成交推送数据，舍弃处理：{}", datas.get("entrust_reference") + "_" + datas.get("futu_entrust_no") + "_" + datas.get("futu_business_no"));
//                        }
//                        break;
//                    case "1010":
//                        // 期货资金变动通知，推送资金变动队列处理（暂无）
//                        break;
//                    default:
//                        break;
//                }
//            } else if ("ofutu.quotation_push".equals(paramString) || "futu.quotation_push".equals(paramString)) {
//                // 整理推送数据
//                Map<String, String> datas = analysisData(sb);
//                // 行情主推
//                RealTimeData rtd = RealTimeData.buildData(datas, paramString);
//
//                log.info("{}--stime--ptime : {}--{}", rtd.getCt() + rtd.getCc(), formate.format(new Date()), formate.format(new Date(rtd.getDt())));
//
////                if (rtd.getCt().contains("DAX")) {
////                    log.info("推送数据:{}", sb.toString());
////                    log.info("解析数据:{}", JSON.toJSONString(rtd));
////                }
//
//                Set<String> keys = redisService.getKeys(CacheID.COMMO_CODE_PREFIX + rtd.getCt() + ":");
//
//                if (CollectionUtils.isNotEmpty(keys)) {
//
//                    keys.stream().forEach(key -> {
//
//                        // 获取期货品种信息
//                        Commo commo = redisService.get(key, Commo.class);
//
//                        if (null != commo) {
//                            //获取当前品种风控参数
//                            CommoRisk commoRisk = redisService.get(CacheID.RISK_PREFIX + commo.getId(), CommoRisk.class);
//                            if (rtd.getCc().equals(commoRisk.getContractNo())) {
//                                // 读取上一个行情推送数据
//                                RealTimeData ortd = redisService.get(CacheID.QUOTE_REAL_PREFIX + commo.getId(), RealTimeData.class);
//                                // 缓存实时行情数据
//                                redisService.put(CacheID.QUOTE_REAL_PREFIX + commo.getId(), rtd);
//                                // 期货实时简要行情缓存MAP
//                                redisService.mapPut(CacheID.QUOTE_SIMPLEREAL_MAP, commo.getId().toString(), SimpleRealData.buildData(rtd));
//
//                                // 限价策略行情驱动下单
//                                ThreadUtil.execute(() -> orderService.doLimitOrderTradeLocal(commo.getId(), rtd.getAp1(), rtd.getBp1()));
//                                // 止盈止损触发平仓
//                                ThreadUtil.execute(() -> orderService.doCoverByLostProfitLocal(rtd.getAp1(), rtd.getBp1(), rtd.getCt()));
//
//                                // 行情主推触发模拟订单相关操作
//                                // 限价策略行情驱动下单
////                              ThreadUtil.execute(() -> orderSimulateService.doLimitOrderTrade(commo.getId(), rtd.getNp()));
//                                // 止盈止损触发平仓
////                              ThreadUtil.execute(() -> orderSimulateService.doCoverByLostProfit(rtd.getNp(), rtd.getCt()));
//
//                                // 计算成交明细数据
//                                ThreadUtil.execute(() -> buildDealDetails(rtd, ortd, commo));
////                              // 计算分时K线数据
////                              ThreadUtil.execute(() -> buildQuoteData(rtd, ortd, commo));
//                            }
//
//                        }
//                    });
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            log.error("解析推送参数失败,错误消息：{}", e.getMessage());
//        }
    }

    /**
     * 计算分时K线数据
     *
     * @param rtd
     * @param ortd
     * @param commo
     */
//    private void buildQuoteData(RealTimeData rtd, RealTimeData ortd, Commo commo) {
//        KData m1 = redisService.get(CacheID.QUOTE_K_CACHE + KData.TYPE.M1.value + commo.getId(), KData.class);
//
//    }

    /**
     * 计算成交明细数据
     *
     * @param rtd   当前成交数据
     * @param ortd  上一个成交数据
     * @param commo 品种
     */
//    private void buildDealDetails(RealTimeData rtd, RealTimeData ortd, Commo commo) {
//        int largeDealDataSize = 200;
//        DealData dd = new DealData();
//        dd.setNp(rtd.getNp());
//        dd.setDt(rtd.getDt());
//        if (commo.getType() == Commo.TYPE.T1.code) {
//            dd.setBa(rtd.getLba());
//        } else {
//            dd.setBa(rtd.getBa() - ortd.getBa() >= 0 ? rtd.getBa() - ortd.getBa() : 0);
//        }
//
//        if (rtd.getNp().compareTo(ortd.getAp1()) == 0) {
//            // 当前最新价 = 上一买一价  买涨成交
//            dd.setDi(1);
//        } else if (rtd.getNp().compareTo(ortd.getBp1()) == 0) {
//            // 当前最新价 = 上一卖一价  买跌成交
//            dd.setDi(2);
//        }
//
//        List<DealData> list = redisService.getList(CacheID.QUOTE_DEAL_PREFIX + commo.getId(), DealData.class);
//        if (list == null) {
//            list = new ArrayList<>();
//        }
//        list.add(dd);
//
//        if (list.size() >= largeDealDataSize) {
//            list.remove(0);
//        }
//
//        redisService.put(CacheID.QUOTE_DEAL_PREFIX + commo.getId(), list);

//    }


    /**
     * 整理推送数据
     *
     * @param sb
     * @return
     */
    private Map<String, String> analysisData(StringBuilder sb) {
        // 接收数据数组
        String[] keys = sb.toString().split("\n")[0].split("\\|");
        String[] vals = sb.toString().split("\n")[1].split("\\|");

        Map<String, String> datas = new HashMap<>();
        for (int i = 0; i < keys.length; i++) {
            datas.put(keys[i], vals[i]);
        }
        return datas;
    }

    @Override
    public void OnRecvTickMsg(MCSubscribeParameter paramMCSubscribeParameter, String paramString) {
        // TODO Auto-generated method stub
    }

}
